/**
 * 全局状态管理
 * 使用Vue.observable实现简单的状态管理
 */
import Vue from 'vue';
import { userApi } from '../utils/api';

// 初始状态
const state = Vue.observable({
  // 用户信息
  userInfo: null,
  // 是否已登录
  isLoggedIn: false,
  // 当前创作任务
  currentTask: null,
  // 最近使用的风格
  recentStyles: [],
  // 收藏的风格
  favoriteStyles: [],
  // 主题设置
  theme: {
    // 主色调
    primaryColor: '#FF69B4',
    // 暗黑模式
    darkMode: false
  }
});

// 方法
const actions = {
  /**
   * 设置用户信息
   * @param {Object} userInfo - 用户信息
   */
  setUserInfo(userInfo) {
    state.userInfo = userInfo;
    state.isLoggedIn = !!userInfo;
    
    // 保存到本地存储
    if (userInfo) {
      uni.setStorageSync('userInfo', JSON.stringify(userInfo));
    } else {
      uni.removeStorageSync('userInfo');
    }
  },
  
  /**
   * 加载用户信息
   * 从本地存储或服务器获取
   * @param {boolean} forceRefresh - 是否强制从服务器刷新
   * @returns {Promise} 返回用户信息
   */
  async loadUserInfo(forceRefresh = false) {
    // 如果已有用户信息且不需要强制刷新，直接返回
    if (state.userInfo && !forceRefresh) {
      return state.userInfo;
    }
    
    // 尝试从本地存储获取
    const userInfoStr = uni.getStorageSync('userInfo');
    if (userInfoStr && !forceRefresh) {
      try {
        const userInfo = JSON.parse(userInfoStr);
        this.setUserInfo(userInfo);
        return userInfo;
      } catch (e) {
        console.error('解析本地用户信息失败', e);
      }
    }
    
    // 从服务器获取
    try {
      const token = uni.getStorageSync('token');
      if (!token) {
        this.setUserInfo(null);
        return null;
      }
      
      const userInfo = await userApi.getUserInfo();
      this.setUserInfo(userInfo);
      return userInfo;
    } catch (e) {
      console.error('获取用户信息失败', e);
      this.setUserInfo(null);
      return null;
    }
  },
  
  /**
   * 用户登录
   * @param {Object} loginData - 登录数据
   * @returns {Promise} 返回登录结果
   */
  async login(loginData) {
    try {
      const response = await userApi.login(loginData);
      
      // 后端返回的数据结构是 ApiResponse，其中 data 包含 token 和 user
      const result = response.data || response;
      
      // 保存token
      if (result && result.token) {
        uni.setStorageSync('token', result.token);
      } else if (response && response.token) {
        uni.setStorageSync('token', response.token);
      } else {
        console.error('登录成功但未获取到token', response);
      }
      
      // 保存用户信息
      if (result && result.user) {
        this.setUserInfo(result.user);
      }
      
      // 获取用户信息（如果上面没有获取到）
      if (!state.userInfo) {
        await this.loadUserInfo(true);
      }
      
      return result || response;
    } catch (e) {
      console.error('登录失败', e);
      throw e;
    }
  },
  
  /**
   * 用户登出
   */
  logout() {
    // 清除token和用户信息
    uni.removeStorageSync('token');
    this.setUserInfo(null);
    
    // 跳转到登录页
    uni.reLaunch({
      url: '/pages/login/login'
    });
  },
  
  /**
   * 设置当前创作任务
   * @param {Object} task - 任务信息
   */
  setCurrentTask(task) {
    state.currentTask = task;
    
    // 保存到本地存储
    if (task) {
      uni.setStorageSync('currentTask', JSON.stringify(task));
    } else {
      uni.removeStorageSync('currentTask');
    }
  },
  
  /**
   * 加载当前创作任务
   * @returns {Object} 返回任务信息
   */
  loadCurrentTask() {
    if (state.currentTask) {
      return state.currentTask;
    }
    
    const taskStr = uni.getStorageSync('currentTask');
    if (taskStr) {
      try {
        const task = JSON.parse(taskStr);
        state.currentTask = task;
        return task;
      } catch (e) {
        console.error('解析本地任务信息失败', e);
      }
    }
    
    return null;
  },
  
  /**
   * 添加最近使用的风格
   * @param {Object} style - 风格信息
   */
  addRecentStyle(style) {
    // 如果已存在，先移除
    const index = state.recentStyles.findIndex(item => item.id === style.id);
    if (index !== -1) {
      state.recentStyles.splice(index, 1);
    }
    
    // 添加到最前面
    state.recentStyles.unshift(style);
    
    // 最多保留10个
    if (state.recentStyles.length > 10) {
      state.recentStyles.pop();
    }
    
    // 保存到本地存储
    uni.setStorageSync('recentStyles', JSON.stringify(state.recentStyles));
  },
  
  /**
   * 加载最近使用的风格
   */
  loadRecentStyles() {
    const stylesStr = uni.getStorageSync('recentStyles');
    if (stylesStr) {
      try {
        state.recentStyles = JSON.parse(stylesStr);
      } catch (e) {
        console.error('解析本地风格信息失败', e);
      }
    }
  },
  
  /**
   * 切换收藏风格
   * @param {Object} style - 风格信息
   * @returns {boolean} 返回是否收藏
   */
  toggleFavoriteStyle(style) {
    const index = state.favoriteStyles.findIndex(item => item.id === style.id);
    
    // 如果已收藏，取消收藏
    if (index !== -1) {
      state.favoriteStyles.splice(index, 1);
      uni.setStorageSync('favoriteStyles', JSON.stringify(state.favoriteStyles));
      return false;
    }
    
    // 添加收藏
    state.favoriteStyles.push(style);
    uni.setStorageSync('favoriteStyles', JSON.stringify(state.favoriteStyles));
    return true;
  },
  
  /**
   * 加载收藏的风格
   */
  loadFavoriteStyles() {
    const stylesStr = uni.getStorageSync('favoriteStyles');
    if (stylesStr) {
      try {
        state.favoriteStyles = JSON.parse(stylesStr);
      } catch (e) {
        console.error('解析本地收藏风格信息失败', e);
      }
    }
  },
  
  /**
   * 检查风格是否已收藏
   * @param {number} styleId - 风格ID
   * @returns {boolean} 返回是否已收藏
   */
  isStyleFavorited(styleId) {
    return state.favoriteStyles.some(item => item.id === styleId);
  },
  
  /**
   * 设置主题
   * @param {Object} theme - 主题设置
   */
  setTheme(theme) {
    state.theme = {
      ...state.theme,
      ...theme
    };
    
    // 保存到本地存储
    uni.setStorageSync('theme', JSON.stringify(state.theme));
  },
  
  /**
   * 加载主题设置
   */
  loadTheme() {
    const themeStr = uni.getStorageSync('theme');
    if (themeStr) {
      try {
        state.theme = {
          ...state.theme,
          ...JSON.parse(themeStr)
        };
      } catch (e) {
        console.error('解析本地主题设置失败', e);
      }
    }
  },
  
  /**
   * 初始化状态
   * 在应用启动时调用
   */
  init() {
    this.loadUserInfo();
    this.loadCurrentTask();
    this.loadRecentStyles();
    this.loadFavoriteStyles();
    this.loadTheme();
  }
};

// 导出状态和方法
export default {
  state,
  ...actions
};
